"""
设备管理API
"""

from flask import Blueprint, request, jsonify
from flask_jwt_extended import jwt_required, get_jwt_identity
from flasgger import swag_from
import qrcode
import io
import base64
from datetime import datetime, timedelta
import requests
import json

from app import db
from app.models import VenueDevice, DeviceAccessCode, DeviceOperationLog, User, Venue, Order, Activity
from app.utils.decorators import admin_required
from app.utils.response import success_response, error_response

device_bp = Blueprint('device', __name__, url_prefix='/v1/device')

@device_bp.route('/venues/<int:venue_id>/devices', methods=['GET'])
@jwt_required()
@admin_required
@swag_from({
    'tags': ['设备管理'],
    'summary': '获取场馆设备列表',
    'description': '管理员获取指定场馆的所有设备信息',
    'parameters': [
        {
            'name': 'venue_id',
            'in': 'path',
            'type': 'integer',
            'required': True,
            'description': '场馆ID'
        }
    ],
    'responses': {
        200: {
            'description': '获取成功',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 200},
                    'message': {'type': 'string', 'example': '操作成功'},
                    'data': {
                        'type': 'object',
                        'properties': {
                            'devices': {
                                'type': 'array',
                                'items': {
                                    'type': 'object',
                                    'properties': {
                                        'id': {'type': 'integer'},
                                        'device_name': {'type': 'string'},
                                        'device_code': {'type': 'string'},
                                        'device_type': {'type': 'string'},
                                        'status': {'type': 'integer'}
                                    }
                                }
                            },
                            'venue': {
                                'type': 'object',
                                'properties': {
                                    'id': {'type': 'integer'},
                                    'name': {'type': 'string'}
                                }
                            }
                        }
                    }
                }
            }
        }
    }
})
def get_venue_devices(venue_id):
    """获取场馆设备列表"""
    try:
        # 检查场馆是否存在
        venue = Venue.query.get(venue_id)
        if not venue:
            return error_response('场馆不存在', 404)
        
        # 获取设备列表
        devices = VenueDevice.query.filter_by(venue_id=venue_id).all()
        
        devices_data = []
        for device in devices:
            device_dict = device.to_dict()
            # 隐藏API密钥
            if device_dict.get('api_key'):
                device_dict['api_key'] = '***'
            devices_data.append(device_dict)
        
        return success_response({
            'devices': devices_data,
            'venue': venue.to_dict()
        })
    
    except Exception as e:
        return error_response(f'获取设备列表失败: {str(e)}')

@device_bp.route('/venues/<int:venue_id>/devices', methods=['POST'])
@jwt_required()
@admin_required
@swag_from({
    'tags': ['设备管理'],
    'summary': '创建场馆设备',
    'description': '管理员为指定场馆创建新设备',
    'parameters': [
        {
            'name': 'venue_id',
            'in': 'path',
            'type': 'integer',
            'required': True,
            'description': '场馆ID'
        },
        {
            'name': 'body',
            'in': 'body',
            'required': True,
            'schema': {
                'type': 'object',
                'required': ['device_name', 'device_code', 'device_type'],
                'properties': {
                    'device_name': {'type': 'string', 'description': '设备名称'},
                    'device_code': {'type': 'string', 'description': '设备编号'},
                    'device_type': {'type': 'string', 'description': '设备类型'},
                    'device_model': {'type': 'string', 'description': '设备型号'},
                    'control_method': {'type': 'string', 'description': '控制方式'},
                    'api_endpoint': {'type': 'string', 'description': 'API接口地址'},
                    'api_key': {'type': 'string', 'description': 'API密钥'}
                }
            }
        }
    ],
    'responses': {
        200: {
            'description': '创建成功',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 200},
                    'message': {'type': 'string', 'example': '设备创建成功'},
                    'data': {
                        'type': 'object',
                        'properties': {
                            'device': {
                                'type': 'object',
                                'properties': {
                                    'id': {'type': 'integer'},
                                    'device_name': {'type': 'string'},
                                    'device_code': {'type': 'string'},
                                    'device_type': {'type': 'string'}
                                }
                            }
                        }
                    }
                }
            }
        }
    }
})
def create_venue_device(venue_id):
    """创建场馆设备"""
    try:
        data = request.get_json()
        
        # 检查场馆是否存在
        venue = Venue.query.get(venue_id)
        if not venue:
            return error_response('场馆不存在', 404)
        
        # 检查设备编号是否已存在
        existing_device = VenueDevice.query.filter_by(device_code=data.get('device_code')).first()
        if existing_device:
            return error_response('设备编号已存在')
        
        # 创建设备
        device = VenueDevice(
            venue_id=venue_id,
            device_type=data.get('device_type'),
            device_name=data.get('device_name'),
            device_code=data.get('device_code'),
            device_model=data.get('device_model'),
            control_method=data.get('control_method'),
            api_endpoint=data.get('api_endpoint'),
            api_key=data.get('api_key'),
            has_access_control=data.get('has_access_control', False),
            access_control_type=data.get('access_control_type'),
            qr_code_duration=data.get('qr_code_duration', 300)
        )
        
        db.session.add(device)
        db.session.commit()
        
        return success_response({'device': device.to_dict()}, '设备创建成功')
    
    except Exception as e:
        db.session.rollback()
        return error_response(f'创建设备失败: {str(e)}')

@device_bp.route('/access-code/generate', methods=['POST'])
@jwt_required()
@swag_from({
    'tags': ['设备管理'],
    'summary': '生成门禁码',
    'description': '用户为指定设备生成临时门禁码和二维码',
    'parameters': [
        {
            'name': 'body',
            'in': 'body',
            'required': True,
            'schema': {
                'type': 'object',
                'required': ['device_id'],
                'properties': {
                    'device_id': {'type': 'integer', 'description': '设备ID'},
                    'order_id': {'type': 'integer', 'description': '订单ID'},
                    'activity_id': {'type': 'integer', 'description': '活动ID'},
                    'max_uses': {'type': 'integer', 'description': '最大使用次数', 'default': 1}
                }
            }
        }
    ],
    'responses': {
        200: {
            'description': '生成成功',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 200},
                    'message': {'type': 'string', 'example': '门禁码生成成功'},
                    'data': {
                        'type': 'object',
                        'properties': {
                            'access_code': {
                                'type': 'object',
                                'properties': {
                                    'id': {'type': 'integer'},
                                    'access_code': {'type': 'string'},
                                    'valid_from': {'type': 'string'},
                                    'valid_until': {'type': 'string'}
                                }
                            },
                            'qr_code': {'type': 'string', 'description': 'Base64编码的二维码图片'}
                        }
                    }
                }
            }
        }
    }
})
def generate_access_code():
    """生成门禁码"""
    try:
        data = request.get_json()
        user_id = get_jwt_identity()
        
        device_id = data.get('device_id')
        order_id = data.get('order_id')
        activity_id = data.get('activity_id')
        
        # 检查设备是否存在
        device = VenueDevice.query.get(device_id)
        if not device:
            return error_response('设备不存在', 404)
        
        # 生成新的门禁码
        access_code = DeviceAccessCode.generate_access_code()
        
        # 生成二维码数据
        qr_data = {
            'device_id': device_id,
            'access_code': access_code,
            'user_id': user_id,
            'timestamp': int(datetime.now().timestamp())
        }
        qr_code_data = json.dumps(qr_data)
        
        # 创建门禁码记录
        valid_from = datetime.now()
        valid_until = valid_from + timedelta(seconds=device.qr_code_duration)
        
        code_record = DeviceAccessCode(
            device_id=device_id,
            user_id=user_id,
            order_id=order_id,
            activity_id=activity_id,
            access_code=access_code,
            qr_code_data=qr_code_data,
            valid_from=valid_from,
            valid_until=valid_until,
            max_uses=data.get('max_uses', 1)
        )
        
        db.session.add(code_record)
        db.session.commit()
        
        # 生成二维码图片
        qr_image = generate_qr_code(qr_code_data)
        
        return success_response({
            'access_code': code_record.to_dict(),
            'qr_code': qr_image
        }, '门禁码生成成功')
    
    except Exception as e:
        db.session.rollback()
        return error_response(f'生成门禁码失败: {str(e)}')

@device_bp.route('/access-code/verify', methods=['POST'])
@swag_from({
    'tags': ['设备管理'],
    'summary': '验证门禁码',
    'description': '设备扫描二维码验证门禁码有效性',
    'parameters': [
        {
            'name': 'body',
            'in': 'body',
            'required': True,
            'schema': {
                'type': 'object',
                'required': ['qr_code_data'],
                'properties': {
                    'qr_code_data': {'type': 'string', 'description': '二维码数据(JSON格式)'}
                }
            }
        }
    ],
    'responses': {
        200: {
            'description': '验证成功',
            'schema': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'integer', 'example': 200},
                    'message': {'type': 'string', 'example': '门禁码验证成功，门已开启'},
                    'data': {
                        'type': 'object',
                        'properties': {
                            'device': {
                                'type': 'object',
                                'properties': {
                                    'id': {'type': 'integer'},
                                    'device_name': {'type': 'string'},
                                    'device_code': {'type': 'string'}
                                }
                            },
                            'user': {
                                'type': 'object',
                                'properties': {
                                    'id': {'type': 'integer'},
                                    'username': {'type': 'string'},
                                    'real_name': {'type': 'string'}
                                }
                            }
                        }
                    }
                }
            }
        }
    }
})
def verify_access_code():
    """验证门禁码"""
    try:
        data = request.get_json()
        qr_code_data = data.get('qr_code_data')
        
        if not qr_code_data:
            return error_response('缺少二维码数据')
        
        # 解析二维码数据
        try:
            qr_data = json.loads(qr_code_data)
        except:
            return error_response('无效的二维码数据')
        
        device_id = qr_data.get('device_id')
        access_code = qr_data.get('access_code')
        
        # 查找门禁码记录
        code_record = DeviceAccessCode.query.filter_by(
            device_id=device_id,
            access_code=access_code
        ).first()
        
        if not code_record:
            return error_response('门禁码不存在')
        
        # 验证门禁码是否有效
        if not code_record.is_valid():
            return error_response('门禁码已失效')
        
        # 使用门禁码
        success = code_record.use_code()
        if not success:
            return error_response('门禁码使用失败')
        
        return success_response({
            'device': code_record.device.to_dict(),
            'user': code_record.user.to_dict() if code_record.user else None
        }, '门禁码验证成功，门已开启')
    
    except Exception as e:
        db.session.rollback()
        return error_response(f'验证门禁码失败: {str(e)}')

def generate_qr_code(data):
    """生成二维码图片"""
    qr = qrcode.QRCode(
        version=1,
        error_correction=qrcode.constants.ERROR_CORRECT_L,
        box_size=10,
        border=4,
    )
    qr.add_data(data)
    qr.make(fit=True)
    
    img = qr.make_image(fill_color="black", back_color="white")
    
    # 转换为base64
    buffer = io.BytesIO()
    img.save(buffer, format='PNG')
    img_str = base64.b64encode(buffer.getvalue()).decode()
    
    return f"data:image/png;base64,{img_str}"
